package org.hyl.javabase.文件;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;

public class CFileTest {
	 String classpath = this.getClass().getResource("").getPath();
	// String courseFile = (new File("")).getCanonicalPath() ;
	static String userdir = System.getProperty("user.dir");
	 URL xmlpath = this.getClass().getResource("selected.xml");
	public static String javaclass = System.getProperty("java.class.path");	
	static String path = userdir + "/src/javabase/test.txt";// 指定文件
	static String writepath = userdir + "/src/javabase/test2.txt";// 指定文件
	
	public String getClassLoader(){
		//System.out.println(this.getClass().getClassLoader().);
		return this.getClass().getClassLoader().getResource("").getPath();
	}
	public static void main(String[] args){
		CFileTest ft=new CFileTest();
//		 System.out.println(CFileTest.class.getResource("/"));
//		 System.out.println(ft. getClassLoader());
//		 System.out.println(javaclass); //?? 类路径与包路径的区别？ 广义上的类路径与狭义类路径
//		 System.out.println(ft.xmlpath);
//		 System.out.println(userdir);
//		 System.out.println(ft.classpath+"test.txt");
	
		//
		try {
			//ft.fileread0();
			ft.fileread0_1();
			//ft.fileread1();
			//ft.fileread2();
			//ft.fileread4();
			//ft.fileread2_1();
			//ft.fileread2_2();
			//ft.filewrite1();
			//ft.filerw();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//只适用于小文件的读取
	public void fileread0(){
		 try {  
			 System.out.println(path);
	            FileInputStream in = new FileInputStream(path); // 读取文件路径   默认读取ansi 编码
	            byte bs[] = new byte[in.available()];  
	            //System.out.println( in.available());
	          
	            in.read(bs);  
	            System.out.println( new String(bs));  
	            in.close();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	        }  
		
	}
	public void fileread0_1(){
		 try {  
			 System.out.println(path);
	            FileInputStream in = new FileInputStream(path); // 读取文件路径   默认读取ansi 编码
	         
	            byte bs[] = new byte[in.available()];  
	            //System.out.println( in.available());
	          
	            in.read(bs);  

	            System.out.println( new String(bs,0,bs.length,"UTF-8"));  
	            in.close();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	        }  
		
	}
	//读文件的例子2 注意 FileInputStream available 的应用
	public void fileread1() {
		try {
			
		
			InputStream is = new FileInputStream(path);// 用文件流读文件
			int size = is.available(); // 分析文件可读的大小
			for (int i = 0; i < size; i++) {// 从第一个字符位置开始 读取文件
				System.out.print((char) is.read());// 一个字一个字输出文件内容 }
			
			}
			is.close(); // 关闭文件
		} catch (IOException e) {
			System.out.println(e);
		}
	}
	//读文件的例子2 注意 File+FileInputStream 的应用
	public void fileread2(){
		try {
			File f = new File(path);
	
			InputStream is = new FileInputStream(f);// 用文件流读文件
	
			int size = is.available(); // 分析文件可读的大小
			for (int i = 0; i < size; i++) {// 从第一个字符位置开始 读取文件
				System.out.print((char) is.read());// 一个字一个字输出文件内容 			
			}
			is.close(); // 关闭文件
		} catch (IOException e) {
			System.out.println(e);
		}
		
	}
	//读文件的例子2 注意 FileInputStream read() != -1的应用
	public void fileread2_1(){
		
		  try {

	            InputStream is = new FileInputStream(path);
	            int i = -1;
	            //当文件指针未读到末尾时
	            while ((i = is.read()) != -1) {
	                System.out.print((char) i);
	            }
	            is.close();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	}
	//读文件的例子2 注意 FileInputStream + byte[] 的应用
	public void fileread2_2() {
		try {

			InputStream in = new FileInputStream(path);
			byte[] temp = new byte[10];
			int i = -1;
			while ((i = in.read(temp)) != -1) {
				String s = new String(temp, 0, i);
				System.out.print(s);
			}
			in.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//读文件的例子4 注意 InputStreamReader + StringBuffer的应用
	public void fileread3() throws IOException{
	
		File f = new File(path);
		FileInputStream fip;
		try {
			fip = new FileInputStream(f);		
		    // 构建FileInputStream对象		    
		    InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
		    // 构建InputStreamReader对象,编码与写入相同		 
		    StringBuilder sb = new StringBuilder();
		    while (reader.ready()) {
		      sb.append((char) reader.read());// 转成char加到StringBuffer对象中		      
		    }
		    System.out.println(sb.toString());
		    reader.close();
		    // 关闭读取流
		    
		    fip.close(); // 关闭输入流,释放系统资源
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		   
		
	}
	//读文件的例子4 注意 FileReader + StringBuffer的应用
	public void fileread4() throws IOException{
		
		File f = new File(path);
		
		try {
			FileReader reader=new FileReader(f); 
		    // 构建FileInputStream对象		    
		  
		    // 构建InputStreamReader对象,编码与写入相同		 
		    StringBuffer sb = new StringBuffer();
		    while (reader.ready()) {
		      sb.append((char) reader.read());// 转成char加到StringBuffer对象中		      
		    }
		    System.out.println(sb.toString());
		    reader.close();    // 关闭读取流
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		   
		
	}
	//读文件的例子5 注意 BufferedReader+StringBuffer的应用
	public void fileread5(){
		 String output = ""; 
		 File file = new File(path);
		    if(file.exists()){
		      if(file.isFile()){
		        try{
		          BufferedReader input = new BufferedReader (new FileReader(file));
		          StringBuffer buffer = new StringBuffer();
		          String text;
		          while((text = input.readLine()) != null)
		            buffer.append(text +"/n");
		          
		          output=buffer.toString();
		       	input.close();
		        }
		        catch(IOException ioException){
		          System.err.println("File Error!");
		        }
		        finally{
		        
		        }
		      }
		      else if(file.isDirectory()){
		        String[] dir = file.list();
		        output += "Directory contents:/n";
		         
		        for(int i=0; i<dir.length; i++){
		          output += dir[i] +"/n";
		        }
		      }
		    }
		    else{
		      System.err.println("Does not exist!");
		    }
	}
	//写入文件的例子
	public void filewrite1(){
		  String str = "是字节转换为字符的桥梁"; // 要写入的内容  
	        try {  
	            FileOutputStream out = new FileOutputStream(writepath); // 输出文件路径  
	            out.write(str.getBytes());  
	            out.close();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	        }  
		
	}
	//边读边写
	public void filerw() {  
        try  
        {  
            // read file content from file  
            StringBuffer sb = new StringBuffer("");  
  
            FileReader reader = new FileReader(path);  
            BufferedReader br = new BufferedReader(reader);  
  
            String str = null;  
  
            while ((str = br.readLine()) != null)  
            {  
                sb.append(str + "\n");  
  
                System.out.println(str);  
            }  
  
            br.close();  
            reader.close();  
  
            // write string to file  
            FileWriter writer = new FileWriter(writepath);  
            BufferedWriter bw = new BufferedWriter(writer);  
            bw.write(sb.toString());  
  
            bw.close();  
            writer.close();  
        } catch (FileNotFoundException e)  
        {  
            e.printStackTrace();  
        } catch (IOException e)  
        {  
            e.printStackTrace();  
        }  
    }  
  
}  



//
//（1）字符与字节： 
//FileInputStream 类以二进制输入/输出，I/O速度快且效率搞，但是它的read（）方法读到的是一个字节（二进制数据），很不利于人们阅读，而且无法直接对文件中的字符进行操作，比如替换，查找（必须以字节形式操作）；
//而Reader类弥补了这个缺陷，可以以文本格式输入/输出，非常方便；比如可以使用while((ch = filereader.read())!=-1 )循环来读取文件；可以使用BufferedReader的readLine()方法一行一行的读取文本。
//（2）编码
//InputStreamReader ，它是字节转换为字符的桥梁。 你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。 
//FileReader与InputStreamReader 涉及编码转换(指定编码方式或者采用os默认编码)，可能在不同的平台上出现乱码现象！而FileInputStream 以二进制方式处理，不会出现乱码现象. 
//因此要指定编码方式时，必须使用InputStreamReader 类，所以说它是字节转换为字符的桥梁；
//(3) 缓存区
//    BufferReader类用来包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。
//（4）规范用法
//总结以上内容，得出比较好的规范用法： 
//1） File file = new File ("hello.txt"); 
//FileInputStream in=new FileInputStream (file); 
//2） File file = new File ("hello.txt"); 
//FileInputStream in=new FileInputStream (file); 
//InputStreamReader inReader=new InputStreamReader (in,"UTF-8"); 
//BufferedReader bufReader=new BufferedReader(inReader); 
//3） File file = new File ("hello.txt"); 
//FileReader fileReader=new FileReader(file); 
//BufferedReader bufReader=new BufferedReader(fileReader);
